package pilhadupla;

import org.junit.Assert;

import org.junit.Test;

public class PilhaDuplaTest {
	
	@Test
	public void testIsEmptyVermelho(){
		PilhaDupla pdupla = new PilhaDupla(10);
		
		Assert.assertTrue(pdupla.isEmptyVermelho());
		pdupla.pushVermelho(0);
		Assert.assertFalse(pdupla.isEmptyVermelho());
		pdupla.popVermelho();
		Assert.assertTrue(pdupla.isEmptyVermelho());
		
	}
	@Test
	public void testSizeVermelho(){
		PilhaDupla pdupla = new PilhaDupla(10);
		
		Assert.assertEquals(0, pdupla.sizeVermelho());
		pdupla.pushVermelho(0);
		
		Assert.assertEquals(1, pdupla.sizeVermelho());
		pdupla.pushVermelho(0);
		pdupla.pushVermelho(0);
		
		Assert.assertEquals(3, pdupla.sizeVermelho());
		pdupla.popVermelho();
		pdupla.popVermelho();
		
		Assert.assertEquals(1, pdupla.sizeVermelho());
		pdupla.popVermelho();
		
		Assert.assertEquals(0, pdupla.sizeVermelho());
	}
	
	@Test
	public void testTopVermelho(){
		PilhaDupla pdupla = new PilhaDupla(10);
		
		pdupla.pushVermelho(0);
		Assert.assertEquals(0, pdupla.topVermelho());
		
		pdupla.pushVermelho(10);
		Assert.assertEquals(10, pdupla.topVermelho());
		
		pdupla.pushVermelho(5);
		Assert.assertEquals(5, pdupla.topVermelho());
		
		pdupla.popVermelho();
		Assert.assertEquals(10, pdupla.topVermelho());
		
		pdupla.popVermelho();
		Assert.assertEquals(0, pdupla.topVermelho());
		
		
	}
	
	@Test(expected=PilhaDuplaException.class)
	public void testTopVermelhoException(){
		
		PilhaDupla pdupla = new PilhaDupla(10);
		
		pdupla.topVermelho();
	}
	
	@Test
	public void testPopVermelho(){
		PilhaDupla pdupla = new PilhaDupla(10);

		pdupla.pushVermelho(0);
		Assert.assertEquals(0, pdupla.popVermelho());
		
		pdupla.pushVermelho(1);
		Assert.assertEquals(1, pdupla.popVermelho());
		
		pdupla.pushVermelho(10);
		pdupla.pushVermelho(11);
		Assert.assertEquals(11, pdupla.popVermelho());
		Assert.assertEquals(10, pdupla.popVermelho());
		
	}
	
	@Test
	public void testPopVermelhoException(){
		
		PilhaDupla pdupla = new PilhaDupla(10);
		
		try {
			pdupla.popVermelho();
			Assert.fail();
		} catch (PilhaDuplaException e) {
			
		}
	}
	
	@Test
	public void testPushVermelho(){
		
		PilhaDupla pdupla = new PilhaDupla(1);
		
		pdupla.pushVermelho(4);
		Assert.assertEquals(4, pdupla.topVermelho());		
	}
	
	@Test
	public void testPushVermelhoException(){
		PilhaDupla pd;
		try {
			pd = new PilhaDupla(0);
			pd.pushVermelho(1);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
		}
		
		try {
			pd = new PilhaDupla(1);
			pd.pushVermelho(1);
			pd.pushVermelho(2);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
		}
		
		try {
			pd = new PilhaDupla(3);
			pd.pushAzul(1);
			pd.pushAzul(10);
			pd.pushVermelho(20);
			pd.pushVermelho(30);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
		}
	}
	
	@Test
	public void testPushAzul(){
		PilhaDupla pd = new PilhaDupla(10);

		pd.pushAzul(1);
		Assert.assertEquals(1, pd.topAzul());
		pd.pushAzul(2);
		Assert.assertEquals(2, pd.topAzul());
	}
	

	@Test
	public void testPushAzulException()
	{
		PilhaDupla pd;
		try {
			pd = new PilhaDupla(0);
			pd.pushAzul(1);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
			
		}
		
		try {
			pd = new PilhaDupla(1);
			pd.pushAzul(1);
			pd.pushAzul(2);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
			
		}
		
		try {
			pd = new PilhaDupla(3);
			pd.pushVermelho(1);
			pd.pushAzul(10);
			pd.pushAzul(20);
			pd.pushAzul(30);
			Assert.fail();
		} catch (PilhaDuplaException pde) {
			
		}
	}
	
	@Test
	public void testPopAzul(){
		PilhaDupla pd = new PilhaDupla(10);

		pd.pushAzul(1);
		Assert.assertEquals(1, pd.popAzul());
		Assert.assertEquals(0, pd.sizeAzul());
		
		pd.pushAzul(1);
		pd.pushAzul(10);
		Assert.assertEquals(10, pd.popAzul());
	}
	
	@Test
	public void testSizeAzul(){
		PilhaDupla pd = new PilhaDupla(10);
		Assert.assertEquals(0, pd.sizeAzul());
		
		pd.pushAzul(1);
		pd.pushAzul(2);
		Assert.assertEquals(2, pd.sizeAzul());
	}
	
	@Test
	public void testIsEmptyAzul(){
		PilhaDupla pd = new PilhaDupla(10);
		Assert.assertTrue(pd.isEmptyAzul());
		pd.pushAzul(1);
		Assert.assertFalse(pd.isEmptyAzul());
		pd.popAzul();
		Assert.assertTrue(pd.isEmptyAzul());
	}
	
	@Test
	public void testPopAzulException(){
		
		PilhaDupla pdupla = new PilhaDupla(10);
		
		try {
			pdupla.popAzul();
			Assert.fail();
		} catch (PilhaDuplaException e) {
			
		}
	}
	@Test
	public void testTopAzul(){
		PilhaDupla pd = new PilhaDupla(10);
		pd.pushAzul(3);
		pd.pushAzul(7);
		Assert.assertEquals(7, pd.topAzul());
		
	}
	
	@Test(expected=PilhaDuplaException.class)
	public void testTopAzulException(){
		
		PilhaDupla pdupla = new PilhaDupla(10);
		
		pdupla.topAzul();
	}
	
}
